home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / g__~1 / gplibs20.zoo / strstrea.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-13  |  5.7 KB  |  238 lines
  1. //    This is part of the iostream library, providing input/output for C++.
  2. //    Copyright (C) 1991 Per Bothner.
  3. //
  4. //    This library is free software; you can redistribute it and/or
  5. //    modify it under the terms of the GNU Library General Public
  6. //    License as published by the Free Software Foundation; either
  7. //    version 2 of the License, or (at your option) any later version.
  8. //
  9. //    This library is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. //    Library General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU Library General Public
  15. //    License along with this library; if not, write to the Free
  16. //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #ifdef __GNUG__
  19. #pragma implementation
  20. #endif
  21. #include <ioprivat.h>
  22. #include <strstrea.h>
  23.  
  24. static void* default_alloc(_G_size_t size)
  25. {
  26.     return (void*)new char[size];
  27. }
  28.  
  29. static void default_free(void* ptr)
  30. {
  31.     delete [] (char*)ptr;
  32. }
  33.  
  34. istrstream::istrstream(const char *cp, _G_size_t n)
  35. {
  36.     init(new strstreambuf(cp, n));
  37. }
  38.  
  39. ostrstream::ostrstream()
  40. {
  41.     init(new strstreambuf());
  42. }
  43.  
  44. strstreambase::strstreambase(char *cp, _G_size_t n, int mode)
  45. {
  46.     char *pstart;
  47.     if (mode == ios::app || mode == ios::ate)
  48.     pstart = cp + strlen(cp);
  49.     else
  50.     pstart = cp;
  51.     init(new strstreambuf(cp, n, pstart));
  52. }
  53.  
  54. char *strstreambuf::str()
  55. {
  56.     freeze(1);
  57.     return base();
  58. }
  59.  
  60. _G_size_t strstreambuf::pcount()
  61. {
  62.     _G_size_t put_len = pptr() - pbase();
  63.     if (put_len < _len) put_len = _len;
  64.     return put_len;
  65. }
  66.  
  67. int strstreambuf::overflow(int c /* = EOF */)
  68. {
  69.   const int flush_only = c == EOF;
  70.   if (_flags & _S_NO_WRITES)
  71.       return flush_only ? 0 : EOF;
  72.   size_t pos = pptr() - pbase();
  73.   size_t get_pos = gptr() - pbase();
  74.   if (pos > _len) _len = pos;
  75.   if (pos >= blen() + flush_only) {
  76.       char *new_buf;
  77.       size_t new_size = 2 * blen();
  78.       if (frozen()) /* not allowed to enlarge */
  79.       return EOF;
  80.       new_buf = (char*)(*_allocate_buffer)(new_size);
  81.       memcpy(new_buf, base(), blen());
  82.       if (new_buf == NULL) {
  83. //      __ferror(fp) = 1;
  84.       return EOF;
  85.       }
  86. #if 0
  87.       if (lenp == &_len) /* use '\0'-filling */
  88.       memset(new_buf + pos, 0, blen() - pos);
  89. #endif
  90.       if (_base) {
  91.       (*_free_buffer)(_base);
  92.       _base = NULL; // So setb() won't try to delete _base.
  93.       }
  94.       setb(new_buf, new_buf + new_size, 1);
  95.     }
  96.  
  97.   setp(base(), ebuf());
  98.   pbump(pos);
  99.   setg(base(), base() + get_pos, base() + _len);
  100.   if (!flush_only) {
  101.       *pptr() = (unsigned char) c;
  102.       pbump(1);
  103.   }
  104.   return c;
  105. }
  106.  
  107. int strstreambuf::underflow()
  108. {
  109.     size_t ppos = pptr() - pbase();
  110.     if (ppos > _len) _len = ppos;
  111.     setg(base(), gptr(), base() + _len);
  112.     if (gptr() < egptr())
  113.     return *gptr();
  114.     else
  115.     return EOF;
  116. }
  117.  
  118.  
  119. void strstreambuf::init_dynamic(_alloc_type alloc, _free_type free,
  120.                 _G_size_t initial_size)
  121.                 
  122. {
  123.     _len = 0;
  124.     if (initial_size < 16)
  125.     initial_size = 16;
  126.     _allocate_buffer = alloc ? alloc : default_alloc;
  127.     _free_buffer = free ? free : default_free;
  128.     char * buf = (char*)(*_allocate_buffer)(initial_size);
  129.     setb(buf, buf + initial_size, 1);
  130.     setp(buf, buf + initial_size);
  131.     setg(buf, buf, buf);
  132. }
  133.  
  134. void strstreambuf::init_static(char *ptr, long size, char *pstart)
  135. {
  136.     if (size == 0)
  137.     size = strlen(ptr);
  138.     else if ((long)size < 0) {
  139.     // If size is negative 'the characters are assumed to
  140.     // continue indefinitely.'  This is kind of messy ...
  141. #if 1
  142.     size = 512;
  143.     // Try increasing powers of 2, as long as we don't wrap around.
  144.     // This can lose in pathological cases (ptr near the end
  145.     // of the address space).  A better solution might be to
  146.     // adjust the size on underflow/overflow.  FIXME.
  147.     for (long s; s = 2*size, s > 0 && ptr + s > ptr && s < 0x4000000L; )
  148.         size = s;
  149.     size = s;
  150. #else
  151.     // The following semi-portable kludge assumes that
  152.     // sizeof(unsigned long) == sizeof(char*). Hence,
  153.     // (unsigned long)(-1) should be the largest possible address.
  154.     unsigned long highest = (unsigned long)(-1);
  155.     // Pointers are signed on some brain-damaged systems, in
  156.     // which case we divide by two to get the maximum signed address.
  157.     if  ((char*)highest < ptr)
  158.         highest >>= 1;
  159.     size = (char*)highest - ptr;
  160. #endif
  161.     }
  162.     setb(ptr, ptr+size);
  163.     if (pstart) {
  164.     setp(ptr, ebuf());
  165.     pbump(pstart-ptr);
  166.     setg(ptr, ptr, pstart);
  167.     }
  168.     else {
  169.     setp(ptr, ptr); 
  170.     setg(ptr, ptr, ebuf());
  171.     }
  172.     _len = egptr() - ptr;
  173. }
  174.  
  175. void strstreambuf::init_static (const char *ptr, long size)
  176. {
  177.   init_static((char*)ptr, size, NULL);
  178.   xsetflags(_S_NO_WRITES);
  179. }
  180.  
  181. strstreambuf::~strstreambuf()
  182. {
  183.     if (_base && !(_flags & _S_USER_BUF))
  184.         (_free_buffer)(_base);
  185.     _base = NULL;
  186. }
  187.  
  188. streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
  189.                     int mode /*=ios::in|ios::out*/)
  190. {
  191.     size_t cur_size = pcount();
  192.     streampos new_pos = EOF;
  193.  
  194.     // Move the get pointer, if requested.
  195.     if (mode & ios::in) {
  196.     switch (dir) {
  197.       case ios::end:
  198.         off += cur_size;
  199.         break;
  200.       case ios::cur:
  201.         off += gptr() - pbase();
  202.         break;
  203.       default: /*case ios::beg: */
  204.         break;
  205.     }
  206.     if (off < 0 || (size_t)off > cur_size)
  207.         return EOF;
  208.     setg(base(), base() + off, base() + cur_size);
  209.     new_pos = off;
  210.     }
  211.  
  212.     // Move the put pointer, if requested.
  213.     if (mode & ios::out) {
  214.     switch (dir) {
  215.       case ios::end:
  216.         off += cur_size;
  217.         break;
  218.       case ios::cur:
  219.         off += pptr() - pbase();
  220.         break;
  221.       default: /*case ios::beg: */
  222.         break;
  223.     }
  224.     if (off < 0 || (size_t)off > cur_size)
  225.         return EOF;
  226.     pbump(base() + off - pptr());
  227.     new_pos = off;
  228.     }
  229.     return new_pos;
  230. }
  231.  
  232. int strstreambuf::pbackfail(int c)
  233. {
  234.     if ((_flags & _S_NO_WRITES) && c != EOF)
  235.     return EOF;
  236.     return backupbuf::pbackfail(c);
  237. }
  238.